package cn.iocoder.yudao.module.reading.service.page;

import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.module.reading.controller.admin.page.vo.BookPageCreateReqVO;
import cn.iocoder.yudao.module.reading.controller.admin.page.vo.BookPagePageReqVO;
import cn.iocoder.yudao.module.reading.controller.admin.page.vo.BookPageUpdateReqVO;
import cn.iocoder.yudao.module.reading.dal.dataobject.book.BookPageDO;
import cn.iocoder.yudao.module.reading.dal.mysql.book.BookPageMapper;
import cn.iocoder.yudao.module.reading.service.book.AdminPictureBookService;
import cn.iocoder.yudao.module.reading.framework.util.StaticResourceUrlUtils;
import cn.hutool.core.util.StrUtil;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import static cn.iocoder.yudao.module.reading.enums.ErrorCodeConstants.BOOK_PAGE_NOT_EXISTS;
import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;

/**
 * 管理员绘本页面 Service 实现类
 *
 * @author 芋道源码
 */
@Service
@Validated
@Slf4j
public class AdminBookPageServiceImpl implements AdminBookPageService {

    @Resource
    private BookPageMapper bookPageMapper;

    @Resource
    private AdminPictureBookService adminPictureBookService;

    @Resource
    private StaticResourceUrlUtils staticResourceUrlUtils;

    @Override
    public Long createBookPage(BookPageCreateReqVO createReqVO) {
        // 转换为DO对象
        BookPageDO page = BeanUtils.toBean(createReqVO, BookPageDO.class);
        page.setIsActive(true);

        // 处理文件URL：将完整URL转换为相对路径存储
        if (StrUtil.isNotEmpty(page.getImageUrl())) {
            String relativePath = staticResourceUrlUtils.toRelativePath(page.getImageUrl());
            page.setImageUrl(relativePath);
            log.debug("页面图片URL标准化: {} -> {}", createReqVO.getImageUrl(), relativePath);
        }
        if (StrUtil.isNotEmpty(page.getOfficialAudioUrl())) {
            String relativePath = staticResourceUrlUtils.toRelativePath(page.getOfficialAudioUrl());
            page.setOfficialAudioUrl(relativePath);
            log.debug("页面音频URL标准化: {} -> {}", createReqVO.getOfficialAudioUrl(), relativePath);
        }

        // 插入数据库
        bookPageMapper.insert(page);

        // 更新对应绘本的页面数量
        adminPictureBookService.updateBookPageCount(page.getBookId());

        log.info("绘本页面创建成功，ID: {}, 绘本ID: {}, 页码: {}",
                page.getId(), page.getBookId(), page.getPageNumber());
        return page.getId();
    }

    @Override
    public void updateBookPage(BookPageUpdateReqVO updateReqVO) {
        // 校验存在
        validateBookPageExists(updateReqVO.getId());

        // 转换为DO对象
        BookPageDO updateObj = BeanUtils.toBean(updateReqVO, BookPageDO.class);

        // 处理文件URL：将完整URL转换为相对路径存储
        if (StrUtil.isNotEmpty(updateObj.getImageUrl())) {
            String relativePath = staticResourceUrlUtils.toRelativePath(updateObj.getImageUrl());
            updateObj.setImageUrl(relativePath);
            log.debug("页面图片URL标准化: {} -> {}", updateReqVO.getImageUrl(), relativePath);
        }
        if (StrUtil.isNotEmpty(updateObj.getOfficialAudioUrl())) {
            String relativePath = staticResourceUrlUtils.toRelativePath(updateObj.getOfficialAudioUrl());
            updateObj.setOfficialAudioUrl(relativePath);
            log.debug("页面音频URL标准化: {} -> {}", updateReqVO.getOfficialAudioUrl(), relativePath);
        }

        // 更新数据库
        bookPageMapper.updateById(updateObj);

        log.info("绘本页面更新成功，ID: {}", updateReqVO.getId());
    }

    @Override
    public void deleteBookPage(Long id) {
        // 校验存在
        validateBookPageExists(id);

        // 获取页面信息，用于后续更新绘本页面数量
        BookPageDO page = bookPageMapper.selectById(id);
        Long bookId = page.getBookId();

        // 删除页面
        bookPageMapper.deleteById(id);

        // 更新对应绘本的页面数量
        adminPictureBookService.updateBookPageCount(bookId);

        log.info("绘本页面删除成功，ID: {}", id);
    }

    @Override
    public BookPageDO getBookPage(Long id) {
        BookPageDO page = bookPageMapper.selectById(id);
        if (page == null) {
            throw exception(BOOK_PAGE_NOT_EXISTS);
        }
        return page;
    }

    @Override
    public PageResult<BookPageDO> getBookPagePage(BookPagePageReqVO pageReqVO) {
        return bookPageMapper.selectPage(pageReqVO);
    }

    @Override
    public List<BookPageDO> getBookPagesByBookId(Long bookId) {
        return bookPageMapper.selectByBookId(bookId);
    }

    @Override
    public List<Long> batchCreateBookPages(List<BookPageCreateReqVO> createReqVOs) {
        List<Long> pageIds = new ArrayList<>();
        Set<Long> affectedBookIds = new HashSet<>();

        for (BookPageCreateReqVO createReqVO : createReqVOs) {
            // 转换为DO对象
            BookPageDO page = BeanUtils.toBean(createReqVO, BookPageDO.class);
            page.setIsActive(true);

            // 处理文件URL：将完整URL转换为相对路径存储
            if (StrUtil.isNotEmpty(page.getImageUrl())) {
                String relativePath = staticResourceUrlUtils.toRelativePath(page.getImageUrl());
                page.setImageUrl(relativePath);
                log.debug("页面图片URL标准化: {} -> {}", createReqVO.getImageUrl(), relativePath);
            }
            if (StrUtil.isNotEmpty(page.getOfficialAudioUrl())) {
                String relativePath = staticResourceUrlUtils.toRelativePath(page.getOfficialAudioUrl());
                page.setOfficialAudioUrl(relativePath);
                log.debug("页面音频URL标准化: {} -> {}", createReqVO.getOfficialAudioUrl(), relativePath);
            }

            // 插入数据库
            bookPageMapper.insert(page);
            pageIds.add(page.getId());

            // 收集受影响的绘本ID
            affectedBookIds.add(page.getBookId());

            log.info("绘本页面创建成功，ID: {}, 绘本ID: {}, 页码: {}",
                    page.getId(), page.getBookId(), page.getPageNumber());
        }

        // 批量更新受影响绘本的页面数量
        adminPictureBookService.batchUpdateBookPageCount(new ArrayList<>(affectedBookIds));

        log.info("批量创建绘本页面成功，数量: {}, 受影响绘本数量: {}", pageIds.size(), affectedBookIds.size());
        return pageIds;
    }

    @Override
    public Long getNextBookPageId() {
        // 获取当前最大ID
        Long maxId = bookPageMapper.selectMaxId();
        // 计算下一个ID（如果表为空，从1开始）
        Long nextId = (maxId == null ? 0 : maxId) + 1;

        log.info("获取下一个绘本页面ID: {}", nextId);
        return nextId;
    }

    /**
     * 校验绘本页面是否存在
     */
    private void validateBookPageExists(Long id) {
        if (bookPageMapper.selectById(id) == null) {
            throw exception(BOOK_PAGE_NOT_EXISTS);
        }
    }

}
